import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import random
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import warnings
warnings.filterwarnings("ignore")
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
# Configs
pd.options.display.float_format = '{:,.2f}'.format
sns.set(style="whitegrid")
sns.set_palette("Set3")
plt.style.use('seaborn')
seed = 42
np.random.seed(seed)
random.seed(seed)
############### MOD ##################
def pie_plot_one_feat(df, col, title, replaces={}, break_line=False, break_point=10, color_dict=None):
df_col = df[col]
df_col = df_col.replace(replaces)
df_aux = df_col.value_counts().reset_index().rename(
columns={'index': 'Valor', col: 'Quantidade'})
if(break_line):
df_aux['Valor'] = df_aux['Valor'].apply(
lambda x: x if len(x.split(' ')) < break_point else insert_break_line(x) )
if(color_dict):
df_aux['color'] = df_aux['Valor'].map(color_dict)
fig = px.pie(
df_aux, values='Quantidade', names='Valor', title=title,
color_discrete_sequence=df_aux['color'] if color_dict else px.colors.qualitative.Pastel,
)
fig.update_traces(textposition='inside', textinfo='percent+label')
fig.show()
def get_percentage_complex(df1, df_origin, col_target):
"""
Retorna a porcentage de um valor sobre o sum no dataframe original.
Eh necessario fazer manulamente pois se não tiver todas as combinaçoes de cat feats
ao fazer da forma automatica da erro. Entao, eh necessario para haver
AS COMBINAÇÇOES CAT_FEAT CUJA CONTAGEM SEJA ZERO
"""
array = []
df_sum = df_origin[col_target].value_counts().reset_index()
df_sum.columns = [col_target, 'sum']
for index, row in df1.iterrows():
if(row['count'] != 0):
v = 100 * (row['count'] / df_sum[ df_sum[col_target] == row[col_target]]['sum'].iloc[0])
else:
v = 0
array.append(v)
return array
def plotly_cat_to_cat(df, catx, cat2, title='', orderby_func=None):
"""
Amabas devem ser cat feats
orderby_func = muitas vezes a cat_feat eh ordenavel, use essa campos para designar a funcao
TEM QUE VERIFICAR QUANDO NAO TEM TODAS AS CATEGORIAS, AI DA ERRO
"""
cols = [catx, cat2]
# Faz todas as combinações dos valores unicos de cada coluna
# por conta disos, se hovuer nao houver a ocorrencia de uma dessa combinaçoes
# a sua contagem de porcentagem tem que ser feita de forma analogica
# na funcao 'get_percentage_complex'
df_temp = df.groupby(cols).size().to_frame('count').reindex(
pd.MultiIndex.from_product([df[catx].unique(), df[cat2].unique()]), fill_value = 0)
df_temp = df_temp.reset_index().dropna()
df_temp.columns = cols + ['count']
df_temp['percentage'] = get_percentage_complex(df_temp, df, catx)
df_temp['total'] = df_temp['percentage']
df_temp.columns = cols + ['Counts', 'Percentage', 'Total']
fig = px.bar(df_temp, x=catx, y=['Total'], color=cat2,
category_orders=orderby_func, hover_data=['Counts'],
text=df_temp['Percentage'].apply(lambda x: '{0:1.2f}%'.format(x)),
title=title)
fig.show()
def plotly_heatmap_cat_feats(
df, catx, caty, title='', color_scale=None, yaxis_titulo=None,
xaxis_titulo=None, largura=700, altura=450, pct_axis=None,
order_list_x_axis=None, order_list_y_axis=None,
df_original_cuz_is_filtered=None
):
"""
Método que constrói um gráfico/tabela em mapa de calor
Parâmetros:
----------
z: valores para z (eixo z = valor = cor)
x: valores para x (eixo x = cat values)
y: valores para y (eixo y = cat values)
color_scale: uma lista com escala de cores para degrade
title: título do gráfico
yaxis_titulo: titulo para ficar ao lado do eixo y
xaxis_titulo: titulo para ficar ao lado do eixo x
largura: largura do gráfico
altura: altura do gráfico
order_list_x_axis e order_list_y_axis: Ordem para os eixos categoricos
pct_axis: (x||y) converte em porcentagem olhando as linhas (x) ou coluna (y)
df_original_cuz_is_filtered: Se fizer um df.query é capaz de perder combinaçôes de x e y
Mandndo o df original, é possível recuperar e setar como 0
"""
# Pre processing
dft = df[ [catx, caty] ]
dft = dft.groupby([catx,caty]).size().reset_index()
dft.columns = ['catx', 'caty', 'values']
dft = pd.pivot_table(
dft, values='values', index='caty',
columns='catx', aggfunc=np.sum, fill_value=0)
# df_original_cuz_is_filtered (como 'plotly_heatmap_cat_feats_3')
# Caso 'df' ser originário de uma filtragem (exemplo df.query('cargo == "Analista de BI"'))
# Nesse formato eh melhor, pois fazer qualquer filtragem
# O QUE FAZ: a filtragem pode retirar combinaçoes dos eixos x e y, e por isso
# o codigo a seguir insere essa combinaçôes faltante como 0
if(df_original_cuz_is_filtered is not None):
df_original = df_original_cuz_is_filtered
for col in df_original[catx].unique().tolist():
if(col not in dft.columns.tolist()):
# add zero column
dft[col] = 0
for indx in df_original[caty].unique().tolist() :
if(indx not in dft.index.tolist()):
dft.loc[indx] = 0
if(order_list_x_axis):
dft = dft[order_list_x_axis]
if(order_list_y_axis):
dft = dft.reindex(order_list_y_axis)
is_porcentage = not pct_axis is None
# calculate percentage in x-axis
if(pct_axis == 'x'):
for col in dft.columns:
sum_values = dft[col].sum()
dft[col] = round(100*(dft[col] / sum_values), 1)
# calculate percentage in y-axis
if(pct_axis == 'y'):
for index in dft.index:
sum_vals = dft.loc[index].sum()
dft.loc[index] = round(100 * (dft.loc[index] / sum_vals), 2)
fig = go.Figure()
global df_out
df_out = dft
fig.add_trace(go.Heatmap(
z = dft,
x = dft.columns.tolist(),
y = dft.index.tolist(),
# texto para ser apresentado se for porcentagem, converter para porcentagem
text = dft.apply(lambda col: col.round(2).astype(str)+"%") if is_porcentage else dft,
texttemplate = "%{text}",
ygap = 1, # adição de uma linha em volta dos quadrados
xgap = 1, # adição de uma linha em volta dos quadrados
# degrade para se realizar de acordo com os valores
colorscale = color_scale if color_scale else px.colors.sequential.Greys,
showscale = False, # remover a imagem de escala ao lado do gráfico
hovertemplate= "%{x}<br>%{y}<br>%{text}<extra></extra>"
))
fig.update_layout(
title= title,
# xaxis_tickangle = 0, # deixar as labels (ticks) do eixo x horizontalmente
width = largura if not is_porcentage else largura + 200,
height = altura if not is_porcentage else altura + 100,
yaxis_title_text = yaxis_titulo if yaxis_titulo else caty,
xaxis_title_text = xaxis_titulo if xaxis_titulo else catx,
xaxis_title_font_color='grey',# cor da fonte do título eixo X
yaxis_title_font_color='grey',# cor da fonte do título eixo y
# yaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo y
# xaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo x
xaxis_color='grey',# cor das labels (ticks) do eixo X
yaxis_color='grey' # cor das labels (ticks) do eixo y
)
fig.show()
############### MOD ##################
def plotly_heatmap_cat_feats_3(
df, catx, caty, cat3, value_cat_3, title, color_scale=None, yaxis_titulo=None,
xaxis_titulo=None, largura = 700, altura= 450, pct=False,
order_list_x_axis=None):
"""
Método que constrói um gráfico/tabela em mapa de calor
Parâmetros:
----------
z: valores para z (eixo z = valor = cor)
x: valores para x (eixo x = cat values)
y: valores para y (eixo y = cat values)
escala_cor: uma lista com escala de cores para degrade
titulo: título do gráfico
yaxis_titulo: titulo para ficar ao lado do eixo y
xaxis_titulo: titulo para ficar ao lado do eixo x
largura: largura do gráfico
altura: altura do gráfico
pct: se os valores são porcentagem, desta forma já adiciona "%" nos textos
"""
# insert third value
dft = df[ df[cat3] == value_cat_3]
# Pre processing
dft = dft[ [catx, caty] ]
dft = dft.groupby([catx,caty]).size().reset_index()
dft.columns = ['catx', 'caty', 'values']
dft = pd.pivot_table(
dft, values='values', index='caty',
columns='catx', aggfunc=np.sum, fill_value=0)
# handler with third value
# add zero col/row if necessary
all_cols = df[catx].unique().tolist()
all_indexs = df[caty].unique().tolist()
for col in all_cols:
if(col not in dft.columns.tolist()):
# add zero column
dft[col] = 0
for indx in all_indexs :
if(indx not in dft.index.tolist()):
dft.loc[indx] = 0
# order x axis
if(order_list_x_axis):
dft = dft[order_list_x_axis]
fig = go.Figure()
fig.add_trace(go.Heatmap(
z = dft,
x = dft.columns.tolist(),
y = dft.index.tolist(),
# texto para ser apresentado se for porcentagem, converter para porcentagem
text = dft.apply(lambda col: self.porcentagem_texto(col)) if pct else dft,
texttemplate = "%{text}",
ygap = 1, # adição de uma linha em volta dos quadrados
xgap = 1, # adição de uma linha em volta dos quadrados
# degrade para se realizar de acordo com os valores
colorscale = color_scale if color_scale else px.colors.sequential.Greys,
showscale = False, # remover a imagem de escala ao lado do gráfico
hovertemplate= "%{x}<br>%{y}<br>%{text}<extra></extra>"
))
fig.update_layout(
title= title,
# xaxis_tickangle = 0, # deixar as labels (ticks) do eixo x horizontalmente
width = largura,
height = altura,
yaxis_title_text = yaxis_titulo if yaxis_titulo else caty,
xaxis_title_text = xaxis_titulo if xaxis_titulo else catx,
xaxis_title_font_color='grey',# cor da fonte do título eixo X
yaxis_title_font_color='grey',# cor da fonte do título eixo y
# yaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo y
# xaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo x
xaxis_color='grey',# cor das labels (ticks) do eixo X
yaxis_color='grey' # cor das labels (ticks) do eixo y
)
fig.show()
########## mod ###########
def plotly_describe_numberf_by_catf(df, number_feat, cat_feat, title='', color_dict=None):
title = number_feat + ' by ' + cat_feat if not title else title
# dropnan pois se houver nao conegue por as cores corretamente
# e tambem nao muda em nada, pois so faz o box de quem NAO TEM NAN
cols = [number_feat, cat_feat]
adf = df[cols].dropna(axis='index', subset=cols)
if(color_dict):
adf['color'] = adf[cat_feat].map(color_dict)
# Box Plot
fig = px.box(
adf,
x=cat_feat,
y=number_feat,
color=cat_feat,
# isso pode nao esta bem ordenado
color_discrete_sequence=adf['color'].unique() if color_dict else None
)
# Configs
fig.update_layout(
title_text=title,
# title_x=0.5, # se ativado titulo fica no meio
yaxis=dict(
gridcolor='#F5F5F5', # cor das linhas horizontais (do eixo y)
),
plot_bgcolor = "#fff", # fundo da cor branco
)
fig.show()
############### MOD ##################
def plotly_bar_grouped_cat_feats(
df, catx, cat2, title='',orderby_func=None,
percentage=False, color_dict=None, replace_dict=None, legend_dict=None):
"""
+ Parecido com 'plotly_cat_to_cat' mas com as barras separas
Mostra a quantidade/porcentagem de valores de 'cat2' para cada 'catx'
+ Há dois modos: com e sem 'percentage'
- com percentage é a porcentagem do valor em relaçao ao todo da legenda (cat2)
+ @color_dict = mapeia valor de 'cat2' para uma cor'#HEX'
"""
cols = [catx, cat2]
df_temp = df.groupby(cols).size().to_frame('count').reindex(
pd.MultiIndex.from_product([df[catx].unique(), df[cat2].unique()]), fill_value = 0)
df_temp = df_temp.reset_index().dropna()
df_temp.columns = cols + ['count']
df_temp['percentage'] = get_percentage_complex(df_temp, df, catx)
df_temp['total'] = df_temp['percentage']
df_temp.columns = cols + ['Counts', 'Percentage', 'Total']
y_target = 'Counts'
y_axis_title = 'Count'
if(percentage):
map_total_cat2 = df[cat2].value_counts().to_dict()
df_temp['total_cat2'] = df_temp[cat2].map(map_total_cat2)
df_temp['Percentage'] = 100 * (df_temp['Counts'] / df_temp['total_cat2'])
y_target = 'Percentage'
y_axis_title = 'Percentage'
if(color_dict):
df_temp['color'] = df_temp[cat2].map(color_dict)
if(replace_dict):
df_temp[catx].replace(replace_dict, inplace=True)
fig = px.histogram(
df_temp, x=catx, y=y_target, color=cat2,
color_discrete_sequence= df_temp['color'] if color_dict else [],
barmode='group', category_orders=orderby_func,
title=title,
)
fig.update_layout(
yaxis=dict(
title=y_axis_title, # titulo do eixo y
gridcolor='#F5F5F5', # cor das linhas horizontais (do eixo y)
ticksuffix='%' if percentage else '' # adicionar sufixo no eixo y
),
xaxis_zeroline=False,
plot_bgcolor = "#fff", # fundo da cor branco
legend= legend_dict if legend_dict else dict(),
)
fig.show()
from math import floor
def insert_break_line(astring, index_point=5):
"""
Usada para por <br> em textos muitos longos, que acaba atrapalhando na visualização
"""
if(pd.isna(astring)):
return astring
splited = astring.split(' ')
for i in range(floor(len(splited)/index_point)):
splited.insert(index_point * (i+1), '<br>')
return " ".join(splited).replace(' <br> ','<br>')
def replace_mapping_dict(adict, index_point=5):
for key, value in adict.items():
adict[key] = insert_break_line(value, index_point)
return adict
def get_prefix_cols(prefix="('P9", df=df):
# Retorna as colunas do DataFrame que começam com um prefixo
return [x for x in df.columns.tolist() if x.startswith(prefix)]
def replace_map_prefix_cols_options(prefix, df=df):
adict = {}
for el in get_prefix_cols(prefix, df):
if(el.count(')') >= 2):
# evita de tirar 2 ')' quando houver mais de um
temp = el.split("', '")[1].replace("'",'').replace(')','@@@',1)
adict[el] = temp.replace(')','').replace('@@@',')')
else:
adict[el] = el.split("', '")[1].replace("'",'').replace(')','')
return adict
def df_concat_many_options_with_statistics(df, target_col, name_cat, prefix_cols):
# Agrupa dados de varias colunas com a contagem/porcentage/soma
prefix_cols = get_prefix_cols(prefix_cols, df)
df_temp = df[ [target_col] + prefix_cols ]
list_dfs = []
for option_col in prefix_cols:
df_out = df_temp[[target_col ,option_col] ].groupby(
target_col).count().reset_index().rename(
columns={option_col: 'count'}) # df com contagem
df_out['total_final'] = df[option_col].count()
df_out[name_cat] = option_col
df_sum_by_target_col = df_temp[[target_col, option_col]].groupby(target_col).sum().reset_index()
df_out['sum'] = df_sum_by_target_col[option_col]
df_out['percent'] = 100 * (df_out['sum'] / df_out['count'])
list_dfs.append(df_out)
return pd.concat(list_dfs)
df_out = None
def plot_bar_group_many_options(
df, target_col, name_cat, prefix_cols, percentage=False,
color_dict=None, orderby_func=None, title='', replace_dict=None, horizontal=False, legend_dict=None, sort_bars=None
):
df_temp = df_concat_many_options_with_statistics(df, target_col, name_cat, prefix_cols)
y_target, y_axis_title = ('percent', 'Percentage') if percentage else ('sum','Count')
if(replace_dict):
df_temp[name_cat].replace(replace_dict, inplace=True)
if(color_dict):
df_temp['color'] = df_temp[target_col].map(color_dict)
x, y, orientation = name_cat, y_target, 'v'
if(horizontal):
x, y, orientation = y_target, name_cat, 'h'
global df_out
df_out = df_temp
fig = px.bar( # ou histogram, bar fica melhor
df_temp, x=x, y=y, color=target_col, barmode='group',
color_discrete_sequence= df_temp['color'] if color_dict else [],
category_orders=orderby_func, orientation=orientation,
title=title,
)
axis_dict = dict(
title=y_axis_title, # titulo do eixo y
gridcolor='#F5F5F5', # cor das linhas horizontais (do eixo y)
ticksuffix='%' if percentage else '' # adicionar sufixo no eixo y
)
fig.update_layout(
yaxis=axis_dict if orientation=='v' else {'title': ''},
xaxis=axis_dict if orientation=='h' else {},
xaxis_zeroline=False,
plot_bgcolor = "#fff", # fundo da cor branco
legend= legend_dict if legend_dict else dict(),
)
if(horizontal):
fig.update_layout(
height=900, # aumentar altura e largura das barras para agrupar nomes
yaxis_categoryorder = 'total ascending', # ordenar automaticamente
bargap=0.35 # distantancias entre as barras
)
if(sort_bars):
fig.update_layout(xaxis_categoryorder = 'total descending')
fig.show()
# df = pd.read_csv('/kaggle/input/state-of-data-2021/State of Data 2021 - Dataset - Pgina1.csv', low_memory=False)
df = pd.read_csv('./State of Data 2021 - Dataset.csv', low_memory=False)
print('linhas:', df.shape[0], '| colunas:',df.shape[1])
linhas: 2645 | colunas: 356
# CORES
# Defina as cores por essa paletas
# https://plotly.com/python/discrete-color/
# https://www.color-hex.com/color/e8f1f6
# busque 3 cores mais escuras (que nao apreçam pretas)
# a ultima cor clara deve ser quase branco
colors_scales = {
'Cientista de Dados': [
'#f5f9fb', '#d1e4ed', '#a3c9dc',
'#75aecb', '#4693ba', '#1979A9',
'#146087', '#166c98', '#146087',
],
'Analista de BI': [
'#fdfcf3', '#fcf9e7', '#f8edb7',
'#f1db6f', '#efd557', '#E9C310',
'#d1af0e', '#ba9c0c', '#a3880b'
],
'Analista de Dados': [
'#eef6f2', '#ddede5', '#bbdbcb',
'#99cab2', '#77b898', '#56a77f',
'#4d9672', '#448565', '#3c7458',
],
'Engenheiro de Dados': [
'#fcf7f7', '#f7e6e5', '#efcdcb',
'#e7b4b2', '#df9b98', '#d7837f',
'#c17572', '#ac6865', '#965b58',
],
}
colors = {
'Cientista de Dados': '#1979A9',
'Analista de BI': '#E9C310',
'Analista de Dados': '#56A77F',
'Engenheiro de Dados': '#d7837f',
'Júnior' : '#66c5cc',
'Pleno' : '#b497e7',
'Sênior': '#f89c74',
'Gestor': '#fe88b0',
}
discrete_pallete = px.colors.qualitative.Pastel
# LEGENDS CONFIGS
legends = {
'top_out': dict(
title_text='',
orientation="h",
yanchor="bottom",
y=1.02,
xanchor="left",
x=0
),
'right_inside': dict(
xanchor="right",
x=1,
),
}
# CONSTANTS USADAS EM MANY OPTIONS
idx_title = 0
# Renomear colunas
mapping_columns = {
"('P2_f ', 'Cargo Atual')": 'cargo',
"('P2_g ', 'Nivel')": 'nivel',
"('P1_a ', 'Idade')": 'idade',
"('P2_h ', 'Faixa salarial')": 'salario',
"('P2_c ', 'Numero de Funcionarios')": 'numero_funcionarios',
"('P1_h ', 'Nivel de Ensino')": 'ensino',
"('P2_d ', 'Gestor?')": 'gestor',
"('P2_a ', 'Qual sua situação atual de trabalho?')": 'situacao_trabalho',
"('P2_k ', 'Você está satisfeito na sua empresa atual?')": 'satisfeito_com_emprego',
"('P2_i ', 'Quanto tempo de experiência na área de dados você tem?')": 'experiencia_dados',
"('P2_j ', 'Quanto tempo de experiência na área de TI/Engenharia de Software você teve antes de começar a trabalhar na área de dados?')": 'experiencia_ti',
"('P2_n ', 'Você pretende mudar de emprego nos próximos 6 meses?')": 'pretende_mudar_emprego',
"('P2_m ', 'Você participou de entrevistas de emprego nos últimos 6 meses?')": 'entrevista_emprego',
# many options
"('P2_l ', 'Qual o principal motivo da sua insatisfação com a empresa atual?')": 'insatisfacao',
# many options
"('P2_o ', 'Quais os principais critérios que você leva em consideração no momento de decidir onde trabalhar?')": 'considerar_onde_trabalhar',
"('P2_q ', 'Atualmente qual a sua forma de trabalho?')": 'forma_trabalho_atual',
"('P2_r ', 'Qual a forma de trabalho ideal para você?')": 'forma_trabalho_ideal',
"('P2_s ', 'Caso sua empresa decida pelo modelo 100% presencial qual será sua atitude?')": 'caso_trabalhe_presencial',
}
df = df.rename(columns=mapping_columns)
df['experiencia_dados'].replace({
'Não tenho experiência na área de dados': 'Sem experiência'
}, inplace=True)
df['satisfeito_com_emprego'].replace({
'1': 'Sim',
'0': 'Não',
}, inplace=True)
df['experiencia_ti'].replace({
'Não tive experiência na área de TI/Engenharia de Software antes de começar a trabalhar na área de dados':
'Sem experiência em TI antes'
}, inplace=True)
mapping_faixa_salario = {
'Menos de R$ 1.000/mês': 'Menos 1k',
'de R$ 1.001/mês a R$ 2.000/mês': 'Entre 1K e 2K',
'de R$ 2.001/mês a R$ 3000/mês': 'Entre 2K e 3K',
'de R$ 3.001/mês a R$ 4.000/mês': 'Entre 3K e 4K',
'de R$ 4.001/mês a R$ 6.000/mês': 'Entre 4K e 6K',
'de R$ 6.001/mês a R$ 8.000/mês': 'Entre 6K e 8K',
'de R$ 8.001/mês a R$ 12.000/mês': 'Entre 8K e 12K',
'de R$ 12.001/mês a R$ 16.000/mês': 'Entre 12K e 16K',
'de R$ 16.001/mês a R$ 20.000/mês': 'Entre 16K e 20K',
'de R$ 20.001/mês a R$ 25.000/mês': 'Entre 20K e 25K',
'de R$ 25.001/mês a R$ 30.000/mês': 'Entre 25K e 30K',
'de R$ 30.001/mês a R$ 40.000/mês': 'Entre 30K e 40K',
'Acima de R$ 40.001/mês': 'Acima de 40K',
}
df['salario'] = df['salario'].map(mapping_faixa_salario)
salary_order = {"salario": list(mapping_faixa_salario.values()) }
experiencia_dados_order = {'experiencia_dados': [
'Sem experiência', 'Menos de 1 ano', 'de 1 a 2 anos', 'de 2 a 3 anos',
'de 4 a 5 anos','de 6 a 10 anos', 'Mais de 10 anos',
]}
experiencia_ti_order = {'experiencia_ti': [
'Sem experiência em TI antes', 'Menos de 1 ano', 'de 1 a 2 anos',
'de 2 a 3 anos', 'de 4 a 5 anos', 'de 6 a 10 anos', 'Mais de 10 anos'
]}
ensino_order = {'ensino': [
'Prefiro não informar', 'Prefiro não informar', 'Estudante de Graduação',
'Graduação/Bacharelado', 'Pós-graduação', 'Mestrado', 'Doutorado ou Phd',
]}
pretende_mudar_emprego_order = { 'pretende_mudar_emprego': [
'Não estou buscando e não pretendo mudar de emprego nos próximos 6 meses',
'Não estou buscando, mas me considero aberto a outras oportunidades',
'Estou em busca de oportunidades dentro ou fora do Brasil',
'Estou em busca de oportunidades, mas apenas fora do Brasil'
]}
entrevista_emprego_order = { 'entrevista_emprego': [
'Não participei de entrevistas de empregos/processos seletivos nos últimos 6 meses',
'Sim, fiz entrevistas mas não fui aprovado'
'Sim, fui aprovado mas decidi não mudar de emprego',
'Sim, fui aprovado e mudei de emprego',
]}
caso_trabalhe_presencial_order = { 'caso_trabalhe_presencial': [
'Vou aceitar e retornar ao modelo 100% presencial.',
'Vou procurar outra oportunidade no modelo híbrido ou remoto.',
'Vou procurar outra oportunidade no modelo 100% remoto.'
]}
numero_funcionarios_order = { 'numero_funcionarios': [
'de 1 a 5', 'de 6 a 10', 'de 11 a 50', 'de 51 a 100', 'de 101 a 500',
'de 501 a 1000', 'de 1001 a 3000', 'Acima de 3000',
]}
df_full = df.copy() # salvar caso prceisar
'Cientista de Dados', 'Analista de BI', 'Analista de Dados', 'Engenheiro de Dados'
# CARGO:
# Mapeamento do formato: 'Cientista de Dados/Data Scientist' para 'Cientista de Dados'
list_cargos = df['cargo'].value_counts().index.tolist()[:4] # top 4 cargos de dados
dict_mapping_cargos = {x: x.split('/')[0] for x in list_cargos}
df['cargo'] = df['cargo'].replace(dict_mapping_cargos)
list_cargos = list(dict_mapping_cargos.values())
list_cargos
['Cientista de Dados', 'Analista de BI', 'Analista de Dados', 'Engenheiro de Dados']
# FILTRAGEM
df = df[ df['cargo'].isin(list_cargos) ]
print('linhas:', df.shape[0], '| colunas:',df.shape[1])
linhas: 1319 | colunas: 356
df_junior = df[ df['nivel'] == 'Júnior']
print('dataset junior: numero de linhas ::', df_junior.shape[0])
dataset junior: numero de linhas :: 442
Os 4 cargos tem proporções bem parecidas, todos els por ocupam aproximandemente 25% do dataset, sendo que há uma vnatagem a mais para cinecia de dados e uma de menos para engehiro de dados, pois tem respectivamnete 27% e 22%
df_temp = df["cargo"].value_counts().reset_index()
df_temp = df_temp.rename(columns={'index': 'Cargo', "cargo": "Quantidade"})
df_temp['PorcentagemNum'] = round( (df_temp['Quantidade'] / df_temp['Quantidade'].sum()) * 100.0, 2)
df_temp['Porcentagem'] = df_temp['PorcentagemNum'].apply(lambda x: str(format(x, '.2f')) + '%' )
df_temp['color'] = df_temp['Cargo'].map(colors)
fig = px.bar(
df_temp, x='Cargo', y='Quantidade', color='Cargo',
text="Porcentagem", title='Proporção dos cargos',
color_discrete_sequence=df_temp['color'],
)
fig.update_layout(
xaxis_showgrid=False, # remoção de grid para eixo X
xaxis_showline=False, # remoção de linhas de fundo do eixo X
xaxis_zeroline=False,
plot_bgcolor = "#fff", # fundo da cor branco
yaxis_categoryorder = 'total ascending', # ordenar o gráfico na forma decrescente
hovermode=None, # se passar o mouse em cima não acontece nada (False/None)
showlegend=False, # remover legenda
)
fig.show()
Parecida com os cargos, como sao 3 nivesi de senoridade , ambos estao proximos de 33% sendo Junior ocupando exaemtente isso.
É mostrado que 4% estao em pleno que nao estao em Senior.
Mas é interressante que a quantidade seja a mesma
Pleno (37) > Junior (33) > Senior (29)
pie_plot_one_feat(df, 'nivel', 'Niveis de Senioridade', color_dict=colors)
plotly_bar_grouped_cat_feats(
df, 'salario', 'nivel',
'Porcentagem do nivel por salario',
salary_order,
True,
color_dict=colors,
legend_dict=legends['top_out'],
)
Detalhes
plotly_bar_grouped_cat_feats(
df, 'experiencia_dados', 'nivel',
'Porcentagem do nivel por salario',
experiencia_dados_order,
True,
color_dict=colors
)
Consideando os picos tempos então que
plotly_bar_grouped_cat_feats(
df, 'ensino', 'nivel',
'Porcentagem do nivel por salario',
ensino_order,
True,
color_dict=colors
)
plotly_bar_grouped_cat_feats(
df, 'experiencia_ti', 'nivel',
'Exp em Ti antes de entrar em dados',
experiencia_ti_order,
True,
color_dict=colors
)
O nivel de senioridade em TI acompanha o nivel de senioridade
Apesar disso há o caso espcial de'sem exp em Ti'
plotly_describe_numberf_by_catf(df, 'idade', 'nivel', 'Idade por nivel', color_dict=colors)
OS box plots sao semlhantes sendo que
cConslusao JR > PL > SN
Quanto maior o n´veil de Senioridade, mais velho, masi exp (em dados ou em TI antes de entra em dados e MAIOR SALÁRIO
col = 'situacao_trabalho'
df[col] = df[col].apply(lambda x: insert_break_line(x, 5))
plotly_bar_grouped_cat_feats(
df, col, 'nivel',
'situacao_trabalho por nivel',
experiencia_ti_order,
True,
color_dict=colors
)
Quanto mais seniro mais diverso pode ser as possibilidades
df['pretende_mudar_emprego'] = df['pretende_mudar_emprego'].apply(lambda x: insert_break_line(x, 4))
plotly_bar_grouped_cat_feats(
df, 'pretende_mudar_emprego', 'nivel',
'pretende_mudar_emprego por nivel',
pretende_mudar_emprego_order,
True,
color_dict=colors
)
Em 'Estou em busca de de oportunidade dentro ou fora do brasil' o juniros esta acima de todos e o juniro esta o mais baixo em 'apenas fora do brasil'. Da pra concluir entao que o junior busca mais dentro do braasil. e quantos maior senior, mais quer buscar fora
1/3 de todo o ramo está aberto
quanto mais senior, mesno quer mudar de emmprego
col = 'entrevista_emprego'
df[col] = df[col].apply(lambda x: insert_break_line(x, 5))
plotly_bar_grouped_cat_feats(
df, col, 'nivel',
'entrevista de emprego por nivel',
experiencia_ti_order,
True,
color_dict=colors
)
plotly_bar_grouped_cat_feats(
df, 'satisfeito_com_emprego', 'nivel',
'Satisfeito com o emprego?',
experiencia_ti_order,
True,
color_dict=colors
)
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options("('P2_l"), 3)
plot_bar_group_many_options(
df, 'nivel', 'insatisfacao',
"('P2_l", True, colors,
replace_dict=dict_replace,
title='insatisfacao no trabalho')
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options("('P2_o"), 4)
plot_bar_group_many_options(
df, 'nivel', 'considerar_onde_trabalhar',
"('P2_o", True, colors,
replace_dict=dict_replace,
title='considerar_onde_trabalhar')
col = 'caso_trabalhe_presencial'
dict_replace = replace_mapping_dict( { x: x for x in df[col].unique() }, 4)
plotly_bar_grouped_cat_feats(
df, col, 'nivel',
'caso_trabalhe_presencial por nivel',
experiencia_ti_order,
True,
color_dict=colors,
replace_dict=dict_replace,
)
col = 'forma_trabalho_atual'
dict_replace = replace_mapping_dict( { x: x for x in df[col].unique() }, 4)
plotly_bar_grouped_cat_feats(
df, col, 'nivel',
'forma_trabalho_atual por nivel',
experiencia_ti_order,
True,
color_dict=colors,
replace_dict=dict_replace,
)
col = 'forma_trabalho_ideal'
dict_replace = replace_mapping_dict( { x: x for x in df[col].unique() }, 4)
plotly_bar_grouped_cat_feats(
df, col, 'nivel',
'forma_trabalho_ideal por nivel',
experiencia_ti_order,
True,
color_dict=colors,
replace_dict=dict_replace,
)
plotly_bar_grouped_cat_feats(
df_junior, 'salario', 'cargo',
'Porcentagem do cargo por salario para Júnior',
salary_order,
True,
color_dict=colors
)
plotly_bar_grouped_cat_feats(
df, 'salario', 'cargo',
'Porcentagem do cargo por salario considerando todos os níveis de senioridade',
salary_order,
True,
color_dict=colors
)
plotly_heatmap_cat_feats(
df,
"salario",
"nivel",
title='Contagem sem considerar o cargo TODOS OS CARGOS e NIVEIS',
order_list_x_axis=mapping_faixa_salario.values()
)
plotly_heatmap_cat_feats(
df.query('cargo == "Cientista de Dados"'),
"salario",
"nivel",
title='Contagem Salario x Senioridade para Cientista de Dados',
order_list_x_axis=mapping_faixa_salario.values(),
color_scale = colors_scales['Cientista de Dados'],
df_original_cuz_is_filtered=df,
)
plotly_heatmap_cat_feats(
df.query('cargo == "Engenheiro de Dados"'),
"salario",
"nivel",
title='Contagem Salario x Senioridade para Cientista de Dados',
order_list_x_axis=mapping_faixa_salario.values(),
color_scale = colors_scales['Engenheiro de Dados'],
df_original_cuz_is_filtered=df,
)
plotly_heatmap_cat_feats(
df.query('cargo == "Analista de Dados"'),
"salario",
"nivel",
title='Contagem Salario x Senioridade para Analista de Dados',
order_list_x_axis=mapping_faixa_salario.values(),
color_scale = colors_scales['Analista de Dados'],
df_original_cuz_is_filtered=df,
)
plotly_heatmap_cat_feats(
df.query('cargo == "Analista de BI"'),
"salario",
"nivel",
title='Contagem Salario x Senioridade para Cientista de Dados',
order_list_x_axis=mapping_faixa_salario.values(),
color_scale = colors_scales['Analista de BI'],
df_original_cuz_is_filtered=df,
)
col, prefix = "('P4_d ', 'Quais das linguagens listadas abaixo você utiliza no trabalho?')", "('P4_d_"
dict_replace = replace_map_prefix_cols_options(prefix)
plot_bar_group_many_options(
df, 'cargo', col,
prefix, True, colors,
replace_dict=dict_replace,
title='Linguagens usadas por cargo', sort_bars=True)
col, prefix = "('P4_e ', 'Entre as linguagens listadas abaixo, qual é a que você mais utiliza no trabalho?')", "('P4_e_"
dict_replace = replace_map_prefix_cols_options(prefix)
plot_bar_group_many_options(
df, 'cargo', col,
prefix, True, colors,
replace_dict=dict_replace,
title='Linguagens MAIS USADA por cargo ', sort_bars=True)
del_cols = """
('P4_h_e ', 'Superset')
('P4_h_f ', 'Redash')
('P4_h_g ', 'MicroStrategy')
('P4_h_h ', 'IBM Analytics/Cognos')
('P4_h_i ', 'SAP Business Objects')
('P4_h_j ', 'Oracle Business Intelligence')
('P4_h_l ', 'Salesforce/Einstein Analytics')
('P4_h_m ', 'Mode')
('P4_h_o ', 'Birst')
('P4_h_r ', 'SAS Visual Analytics')
('P4_h_t ', 'TIBCO Spotfire')
""".split('\n')[1:-1]
df_temp = df.drop(del_cols, axis='columns')
col, prefix = "('P4_h ', 'Quais as Ferramentas de Business Intelligence você utiliza no trabalho?')", "('P4_h_"
dict_replace = replace_map_prefix_cols_options(prefix, df_temp)
plot_bar_group_many_options(
df_temp, 'cargo', col,
prefix, True, colors,
replace_dict=dict_replace,
title='Ferramenta de BI que utiliza', sort_bars=True)
col, prefix = "('P4_g ', 'Quais das opções de Cloud listadas abaixo você utiliza no trabalho?')", "('P4_g_"
dict_replace = replace_map_prefix_cols_options(prefix)
plot_bar_group_many_options(
df, 'cargo', col,
prefix, True, colors,
replace_dict=dict_replace,
title='Ferramenta de CLOUD que utiliza', sort_bars=True)
## TOP DB
# ('P4_f_c ', 'SQL SERVER')
# ('P4_f_m ', 'PostgreSQL')
# ('P4_f_a ', 'MySQL')
# ('P4_f_b ', 'Oracle')
# ('P4_f_z ', 'Amazon Redshift')
# ('P4_f_l ', 'S3')
# ('P4_f_x ', 'Google BigQuery')
# ('P4_f_i ', 'MongoDB')
# ('P4_f_z3 ', 'Databricks')
# ('P4_f_z8 ', 'Hive')
# ('P4_f_e ', 'Amazon Aurora ou RDS')
# ('P4_f_n ', 'ElasticSearch')
# ('P4_f_z5 ', 'Presto')
# ('P4_f_q ', 'SQLite')
# ('P4_f_z2 ', 'Snowflake')
# ('P4_f_z1 ', 'Amazon Athena')
# ('P4_f_f ', 'Amazon DynamoDB')
## BOTTOM DB
# ('P4_f_d ', 'SAP')
# ('P4_f_g ', 'CoachDB')
# ('P4_f_h ', 'Cassandra')
# ('P4_f_j ', 'MariaDB')
# ('P4_f_k ', 'Datomic')
# ('P4_f_o ', 'DB2')
# ('P4_f_p ', 'Microsoft Access')
# ('P4_f_r ', 'Sybase')
# ('P4_f_s ', 'Firebase')
# ('P4_f_t ', 'Vertica')
# ('P4_f_u ', 'Redis')
# ('P4_f_v ', 'Neo4J')
# ('P4_f_y ', 'Google Firestore')
# ('P4_f_z4 ', 'HBase')
# ('P4_f_z6 ', 'Splunk')
# ('P4_f_z7 ', 'SAP HANA')
# ('P4_f_z9 ', 'Firebird')
del_cols = """
('P4_f_d ', 'SAP')
('P4_f_g ', 'CoachDB')
('P4_f_h ', 'Cassandra')
('P4_f_j ', 'MariaDB')
('P4_f_k ', 'Datomic')
('P4_f_o ', 'DB2')
('P4_f_p ', 'Microsoft Access')
('P4_f_r ', 'Sybase')
('P4_f_s ', 'Firebase')
('P4_f_t ', 'Vertica')
('P4_f_u ', 'Redis')
('P4_f_v ', 'Neo4J')
('P4_f_y ', 'Google Firestore')
('P4_f_z4 ', 'HBase')
('P4_f_z6 ', 'Splunk')
('P4_f_z7 ', 'SAP HANA')
('P4_f_z9 ', 'Firebird')
""".split('\n')[1:-1]
df_temp = df.drop(del_cols, axis='columns')
col, prefix = "('P4_f ', 'Quais dos bancos de dados/fontes de dados listados abaixo você utiliza no trabalho?')", "('P4_f_"
dict_replace = replace_map_prefix_cols_options(prefix, df_temp)
plot_bar_group_many_options(
df_temp, 'cargo', col,
prefix, True, colors,
replace_dict=dict_replace,
title='Banco de Dados utilizado no trabalho - PART 1', sort_bars=True)
del_cols = """
('P4_f_c ', 'SQL SERVER')
('P4_f_m ', 'PostgreSQL')
('P4_f_a ', 'MySQL')
('P4_f_b ', 'Oracle')
('P4_f_z ', 'Amazon Redshift')
('P4_f_l ', 'S3')
('P4_f_x ', 'Google BigQuery')
('P4_f_i ', 'MongoDB')
('P4_f_z3 ', 'Databricks')
('P4_f_z8 ', 'Hive')
('P4_f_e ', 'Amazon Aurora ou RDS')
('P4_f_n ', 'ElasticSearch')
('P4_f_z5 ', 'Presto')
('P4_f_q ', 'SQLite')
('P4_f_z2 ', 'Snowflake')
('P4_f_z1 ', 'Amazon Athena')
('P4_f_f ', 'Amazon DynamoDB')
""".split('\n')[1:-1]
df_temp = df.drop(del_cols, axis='columns')
col, prefix = "('P4_f ', 'Quais dos bancos de dados/fontes de dados listados abaixo você utiliza no trabalho?')", "('P4_f_"
dict_replace = replace_map_prefix_cols_options(prefix, df_temp)
plot_bar_group_many_options(
df_temp, 'cargo', col,
prefix, True, colors,
replace_dict=dict_replace,
title='Banco de Dados utilizado no trabalho - PART 2', sort_bars=True)
df_ds = df.query(" cargo == 'Cientista de Dados'")
secao_ciencia_de_dados = {
"('P8_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual com ciência de dados?')": [
'rotinas de ciencia de dados'
],
"('P8_b ', 'Quais as técnicas e métodos listados abaixo você costuma utilizar no trabalho?')": [
'tecnicas e metodos de em data science'
],
"('P8_c ', 'Quais dessas tecnologias fazem parte do seu dia a dia como cientista de dados?')": [
'tecnologias usadas em ciencia de dados'
],
"('P8_d ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo no trabalho?')": [
'onde voce mais gasta tempo'
],
}
for pergunta, params in secao_ciencia_de_dados.items():
col = pergunta
prefix = col[:6] + '_'
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 6)
for el in dict_replace.values():
print(el)
plot_bar_group_many_options(
df_ds, 'nivel', col,
prefix, True, colors,
replace_dict=dict_replace,
title=params[idx_title],
horizontal=True,
legend_dict=legends['top_out']
)
Estudos Ad-hoc com o objetivo de<br>confirmar hipóteses, realizar modelos preditivos,<br>forecasts, análise de cluster para<br>resolver problemas pontuais e responder<br>perguntas das áreas de negócio. Sou responsável pela coleta e limpeza<br>dos dados que uso para<br>análise e modelagem. Sou responsável por entrar em contato<br>com os times de negócio<br>para definição do problema, identificar<br>a solução e apresentação de resultados. Desenvolvo modelos de Machine Learning com<br>o objetivo de colocar em<br>produção em sistemas (produtos de dados). Sou responsável por colocar modelos em<br>produção, criar os pipelines de<br>dados, APIs de consumo e monitoramento. Cuido da manutenção de modelos de<br>Machine Learning já em produção,<br>atuando no monitoramento, ajustes e<br>refatoração quando necessário. Realizo construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik, etc Utilizo ferramentas avançadas de estatística como<br>SAS, SPSS, Stata etc, para<br>realizar análises estatísticas e ajustar<br>modelos.Crio e dou manutenção em<br>ETLs, DAGs e automações de pipelines de dados. Sou responsável por criar e manter<br>a infra que meus modelos<br>e soluções rodam (clusters, servidores,<br>API, containers, etc.)
Utilizo modelos de regressão (linear, logística,<br>GLM) Utilizo redes neurais ou modelos baseados<br>em árvore para criar modelos<br>de classificação Desenvolvo sistemas de recomendação (RecSys) Utilizo métodos estatísticos Bayesianos para analisar<br>dados Utilizo técnicas de NLP (Natural Language<br>Processing) para análisar dados não-estruturados Utilizo métodos estatísticos clássicos (Testes de<br>hipótese, análise multivariada, sobrevivência, dados<br>longitudinais, inferência estatistica) para analisar dados Utilizo cadeias de Markov ou HMMs<br>para realizar análises de dados Desenvolvo técnicas de Clusterização (K-means, Spectral,<br>DBScan etc) Realizo previsões através de modelos de<br>Séries Temporais (Time Series) Utilizo modelos de Reinforcement Learning (aprendizado<br>por reforço) Utilizo modelos de Machine Learning para<br>detecção de fraude Utilizo métodos de Visão Computacional Utilizo modelos de Detecção de Churn <br>
Ferramentas de BI (PowerBI, Looker, Tableau,<br>Qlik etc) Planilhas (Excel, Google Sheets etc) Ambientes de desenvolvimento local (R-studio, JupyterLab,<br>Anaconda) Ambientes de desenvolvimento na nuvem (Google<br>Colab, AWS Sagemaker, Kaggle Notebooks<br>etc) Ferramentas de AutoML (Datarobot, H2O, Auto-Keras<br>etc) Ferramentas de ETL (Apache Airflow, NiFi,<br>Stitch, Fivetran, Pentaho etc) Plataformas de Machine Learning (TensorFlow, Azure<br>Machine Learning, Kubeflow etc) Feature Store (Feast, Hopsworks, AWS Feature<br>Store, Databricks Feature Store etc) Sistemas de controle de versão (Github,<br>DVC, Neptune, Gitlab etc) Plataformas de Data Apps (Streamlit, Shiny,<br>Plotly Dash etc) Ferramentas de estatística avançada como SPSS,<br>SAS, etc. Não utilizo nenhuma dessas ferramentas no<br>meu dia a dia.
Coletando e limpando os dados que<br>uso para análise e modelagem. Entrando em contato com os times<br>de negócio para definição do<br>problema, identificar a solução e<br>apresentação de resultados. Desenvolvendo modelos de Machine Learning com<br>o objetivo de colocar em<br>produção em sistemas (produtos de dados). Colocando modelos em produção, criando os<br>pipelines de dados, APIs de<br>consumo e monitoramento. Cuidando da manutenção de modelos de<br>Machine Learning já em produção,<br>atuando no monitoramento, ajustes e<br>refatoração quando necessário. Realizando construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik, etc. Criando e dando manutenção em ETLs,<br>DAGs e automações de pipelines<br>de dados. Criando e gerenciando soluções de Feature<br>Store e cultura de MLOps. Criando e mantendo a infra que<br>meus modelos e soluções rodam<br>(clusters, servidores, API, containers, etc.)
df_de = df.query(" cargo == 'Engenheiro de Dados'")
secao_engenharia_de_dados = {
"('P6_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual como engenheiro de dados?')": [
'Quais rotinas fazem parte da sua rotina como Engenheiro de dados?'
],
"('P6_b ', 'Quais as ferramentas/tecnologias de ETL que você utiliza no trabalho como Data Engineer?')": [
'Qauis tecnologias de ETL você utiliza como Engenheiro de dados'
],
"('P6_g ', 'Quais as ferramentas de gestão de Qualidade de dados, Metadados e catálogo de dados você utiliza no trabalho?')": [
'Ferramentas de Gestão de Qualidade de dados usadas em sua rotina de Engeheiro de dados'
],
"('P6_h ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo?')": [
'Em qual atividade você gasta mais tempo como cientista de dados'
],
}
for pergunta, params in secao_engenharia_de_dados.items():
col = pergunta
prefix = col[:6] + '_'
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 6)
for el in dict_replace.values():
print(el)
plot_bar_group_many_options(
df_de, 'nivel', col,
prefix, True, colors,
replace_dict=dict_replace,
title=params[idx_title],
horizontal=True,
legend_dict=legends['top_out']
)
Desenvolvo pipelines de dados utilizando linguagens<br>de programação como Python, Scala,<br>Java etc. Realizo construções de ETLs em ferramentas<br>como Pentaho, Talend, Dataflow etc. Crio consultas através da linguagem SQL<br>para exportar informações e compartilhar<br>com as áreas de negócio. Atuo na integração de diferentes fontes<br>de dados através de plataformas<br>proprietárias como Stitch Data, Fivetran etc. Modelo soluções de arquitetura de dados,<br>criando componentes de ingestão de<br>dados, transformação e recuperação da informação. Desenvolvo/cuido da manutenção de repositórios de<br>dados baseados em streaming de<br>eventos como Data Lakes e<br>Data Lakehouses. Atuo na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados como Data Warehouses,<br>Data Marts etc. Cuido da qualidade dos dados, metadados<br>e dicionário de dados. Nenhuma das opções listadas refletem meu<br>dia a dia.
Scripts Python SQL & Stored Procedures Apache Airflow Luigi AWS Glue Talend Stitch Fivetran Google Dataflow Oracle Data Integrator IBM DataStage SAP BW ETL SQL Server Integration Services (SSIS) SAS Data Integration Qlik Sense Knime Não utilizo ferramentas de ETL
great_expectations dbt AWS Deequ Apache Griffin Datafold Amundsen Monte Carlo SODA Big Eye Data Band Anomalo Metaplane Acceldata
Desenvolvendo pipelines de dados utilizando linguagens<br>de programação como Python, Scala,<br>Java etc. Realizando construções de ETLs em ferramentas<br>como Pentaho, Talend, Dataflow etc. Criando consultas através da linguagem SQL<br>para exportar informações e compartilhar<br>com as áreas de negócio. Atuando na integração de diferentes fontes<br>de dados através de plataformas<br>proprietárias como Stitch Data, Fivetran etc. Modelando soluções de arquitetura de dados,<br>criando componentes de ingestão de<br>dados, transformação e recuperação da informação. Desenvolvendo/cuidando da manutenção de repositórios de<br>dados baseados em streaming de<br>eventos como Data Lakes e<br>Data Lakehouses. Atuando na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados como Data Warehouses,<br>Data Marts etc. Cuidando da qualidade dos dados, metadados<br>e dicionário de dados.
df_da = df.query(" cargo == 'Analista de Dados'")
secao_analise_de_dados = {
"('P7_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual com análise de dados?')": [
'rotinas de analise de dados'
],
"('P7_b ', 'Quais as ferramentas/tecnologias de ETL que você utiliza no trabalho como Data Analyst?')": [
'ferramentas de ETL em dataAnalyse'
],
"('P7_c ', 'Sua empresa utiliza alguma das ferramentas listadas para dar mais autonomia em análise de dados para as áreas de negócio?')": [
'onde trabalha utiliza uma forma automatizada de analise'
],
"('P7_d ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo de trabalho?')": [
'onde voce mais gasta tempo'
],
}
for pergunta, params in secao_analise_de_dados.items():
col = pergunta
prefix = col[:6] + '_'
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 4)
for el in dict_replace.values():
print(el)
plot_bar_group_many_options(
df_da, 'nivel', col,
prefix, True, colors,
replace_dict=dict_replace,
title=params[idx_title],
horizontal=True,
legend_dict=legends['top_out']
)
Processo e analiso dados<br>utilizando linguagens de<br>programação como Python,<br>R etc. Realizo construções de dashboards<br>em ferramentas de<br>BI como PowerBI,<br>Tableau, Looker, Qlik etc. Utilizo APIs para extrair<br>dados e complementar<br>minhas análises. Realizo experimentos e estudos<br>utilizando metodologias estatísticas<br>como teste de<br>hipótese, modelos de regressão etc. Desenvolvo/cuido da manutenção de<br>ETLs utilizando tecnologias<br>como Talend, Pentaho,<br>Airflow, Dataflow etc. Atuo na modelagem dos<br>dados, com o<br>objetivo de criar<br>conjuntos de dados,<br>Data Warehouses, Data Marts etc. Desenvolvo/cuido da manutenção de<br>planilhas para atender<br>as áreas de negócio. Utilizo ferramentas avançadas de<br>estatística como SAS
Scripts Python SQL & Stored Procedures <br> Apache Airflow Luigi AWS Glue Talend Stitch Fivetran Google Dataflow Oracle Data Integrator IBM DataStage SAP BW ETL SQL Server Integration Services<br>(SSIS) SAS Data Integration Qlik Sense Knime Não utilizo ferramentas de<br>ETL
Ferramentas de AutoML como<br>H2O.ai, Data Robot,<br>BigML etc. ""Point and Click"" Analytics<br>como Alteryx, Knime,<br>Rapidminer etc. Product metricts & Insights<br>como Mixpanel, Amplitude,<br>Adobe Analytics. Ferramentas de análise dentro<br>de ferramentas de<br>CRM como Salesforce<br>Einstein Anaytics ou Zendesk dashboards. Minha empresa não utiliza<br>essas ferramentas. Não sei informar.
Processando e analisando dados<br>utilizando linguagens de<br>programação como Python,<br>R etc. Realizando construções de dashboards<br>em ferramentas de<br>BI como PowerBI,<br>Tableau, Looker, Qlik etc. Utilizando APIs para extrair<br>dados e complementar<br>minhas análises. Realizando experimentos e estudos<br>utilizando metodologias estatísticas<br>como teste de<br>hipótese, modelos de regressão etc. Desenvolvendo/cuidando da manutenção de<br>ETLs utilizando tecnologias<br>como Talend, Pentaho,<br>Airflow, Dataflow etc. Atuando na modelagem dos<br>dados, com o<br>objetivo de criar<br>conjuntos de dados,<br>Data Warehouses, Data Marts etc. Desenvolvendo/cuidando da manutenção de<br>planilhas do Excel<br>ou Google Sheets<br>para atender as<br>áreas de negócio. Utilizando ferramentas avançadas de<br>estatística como SAS,<br>SPSS, Stata etc,<br>para realizar análises.
df_bi = df.query(" cargo == 'Analista de BI'")
secao_analise_de_dados = {
"('P7_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual com análise de dados?')": [
'rotinas de analise de dados'
],
"('P7_b ', 'Quais as ferramentas/tecnologias de ETL que você utiliza no trabalho como Data Analyst?')": [
'ferramentas de ETL em dataAnalyse'
],
"('P7_c ', 'Sua empresa utiliza alguma das ferramentas listadas para dar mais autonomia em análise de dados para as áreas de negócio?')": [
'onde trabalha utiliza uma forma automatizada de analise'
],
"('P7_d ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo de trabalho?')": [
'onde voce mais gasta tempo'
],
}
for pergunta, params in secao_analise_de_dados.items():
col = pergunta
prefix = col[:6] + '_'
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 6)
for el in dict_replace.values():
print(el)
plot_bar_group_many_options(
df_bi, 'nivel', col,
prefix, True, colors,
replace_dict=dict_replace,
title=params[idx_title],
horizontal=True,
legend_dict=legends['top_out']
)
Processo e analiso dados utilizando linguagens<br>de programação como Python, R<br>etc. Realizo construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik etc. Utilizo APIs para extrair dados e<br>complementar minhas análises. Realizo experimentos e estudos utilizando metodologias<br>estatísticas como teste de hipótese,<br>modelos de regressão etc. Desenvolvo/cuido da manutenção de ETLs utilizando<br>tecnologias como Talend, Pentaho, Airflow,<br>Dataflow etc. Atuo na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados, Data Warehouses, Data<br>Marts etc. Desenvolvo/cuido da manutenção de planilhas para<br>atender as áreas de negócio. Utilizo ferramentas avançadas de estatística como<br>SAS
Scripts Python SQL & Stored Procedures Apache Airflow Luigi AWS Glue Talend Stitch Fivetran Google Dataflow Oracle Data Integrator IBM DataStage SAP BW ETL SQL Server Integration Services (SSIS) SAS Data Integration Qlik Sense Knime Não utilizo ferramentas de ETL
Ferramentas de AutoML como H2O.ai, Data<br>Robot, BigML etc. ""Point and Click"" Analytics como Alteryx,<br>Knime, Rapidminer etc. Product metricts & Insights como Mixpanel,<br>Amplitude, Adobe Analytics. Ferramentas de análise dentro de ferramentas<br>de CRM como Salesforce Einstein<br>Anaytics ou Zendesk dashboards. Minha empresa não utiliza essas ferramentas. <br> Não sei informar.
Processando e analisando dados utilizando linguagens<br>de programação como Python, R<br>etc. Realizando construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik etc. Utilizando APIs para extrair dados e<br>complementar minhas análises. Realizando experimentos e estudos utilizando metodologias<br>estatísticas como teste de hipótese,<br>modelos de regressão etc. Desenvolvendo/cuidando da manutenção de ETLs utilizando<br>tecnologias como Talend, Pentaho, Airflow,<br>Dataflow etc. Atuando na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados, Data Warehouses, Data<br>Marts etc. Desenvolvendo/cuidando da manutenção de planilhas do<br>Excel ou Google Sheets para<br>atender as áreas de negócio. Utilizando ferramentas avançadas de estatística como<br>SAS, SPSS, Stata etc, para<br>realizar análises.
for el in dict_replace.values():
print(el)
Processando e analisando dados utilizando linguagens<br>de programação como Python, R<br>etc. Realizando construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik etc. Utilizando APIs para extrair dados e<br>complementar minhas análises. Realizando experimentos e estudos utilizando metodologias<br>estatísticas como teste de hipótese,<br>modelos de regressão etc. Desenvolvendo/cuidando da manutenção de ETLs utilizando<br>tecnologias como Talend, Pentaho, Airflow,<br>Dataflow etc. Atuando na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados, Data Warehouses, Data<br>Marts etc. Desenvolvendo/cuidando da manutenção de planilhas do<br>Excel ou Google Sheets para<br>atender as áreas de negócio. Utilizando ferramentas avançadas de estatística como<br>SAS, SPSS, Stata etc, para<br>realizar análises.